home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Mediterranean / Mediterranean Tiny.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.4 KB  |  1,570 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Mediterranean Tiny.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 9/14/01 10:07a $
  11. // $Revision: 9 $
  12. // $Revision: 9 $Revision: 8
  13. //   Adjusted Angle between team members 
  14. // Revision: 9 
  15. //    Pushed players and outer neutrals toward the map edge
  16. //    increased land, trees, decreased outer neutrals and flat land 
  17. //    Assumes Initial Step = 64 in Mediterranean.rmv
  18. //  Revision: 15 Revised for miniaturization
  19. //  Revision: 16 Elevation 
  20. //  Revision: 17 Revised # of resources 3 by 3
  21. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  22. //  Revision: 19 General adjustments
  23. //  Revision: 20 Reduced congestion 
  24. //  Revision: 23 Reduced Resources
  25. //  Revision: 24 Added Chance of steep cliffs 
  26. //  Revision: 26 Evened-out resource distribution 
  27. //  Revision: 28 Moved resources 2 tiles further from Capitol
  28. //  Revision: 30 Added 1 forage site
  29. //
  30. //////////////////////////////////////////////////////////////////////
  31.  
  32. #if            NOTDEFINED(MEDITERRANEAN_TINY_RMV)
  33. #define        (MEDITERRANEAN_TINY_RMV,1)
  34.  
  35. //////////////////////////////////////////////////////////////////////
  36. // Definitions we are required to define for Mediterranean maps
  37. //////////////////////////////////////////////////////////////////////
  38.  
  39. ResourcePlacementLimit (Gold,     7,    11)
  40. ResourcePlacementLimit (Steel,     7,     11)
  41. ResourcePlacementLimit (Stone,     7,     11)
  42. ResourcePlacementLimit (Berry,     6,     10)
  43. ResourcePlacementLimit (Fish,     1,    50)
  44. ResourcePlacementLimit (Tree,     3,     6)
  45. ResourcePlacementLimit (Animal,     7,     15)
  46.  
  47. #if Is2Players
  48. //////////////////////////////////////////////////////////////////////
  49. // 2 PLAYERS...
  50. //////////////////////////////////////////////////////////////////////
  51.  
  52. //////////////////////////////////////////////////////////////////////
  53. // terrain definitions
  54. #define        (kMinIntElevation,            -8)
  55. #define        (kMaxIntElevation,            6)
  56. #define        (kElevationScale,                1)
  57. #define        (kPercentLand,                Between(.66, .66))
  58. #define        (kWaterBorder,                0)
  59. #define        (kHeightMapChaos,                Between(6, 10))
  60.                                             
  61. #define        (kMinimumStartPositionToMapEdge    1)
  62. #define        (kOuterPushFromMapCenter        24)
  63. #define        (kInnerPushFromMapCenter         0)
  64.  
  65. #define        (kConvergentSampleSize,            32) 
  66. #define        (kConvergentThreshold,            20000)
  67.  
  68. //////////////////////////////////////////////////////////////////////
  69. // player definitions
  70. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  71. #define        (kPlayerInnerRadius,            0.8)
  72. #define        (kPlayerOuterRadius,            0.99)
  73. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  74. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  75. #define        (kPlayerLandChaos,            0.8)
  76. #define        (kPlayerLandClumps,            1)
  77. #define        (kPlayerFlatChaos,            0.8)
  78. #define        (kPlayerFlatClumps,            1)
  79. #define        (kPlayerTreePercentage,            0.15)
  80.  
  81.  
  82. //////////////////////////////////////////////////////////////////////
  83. // inner neutral definitions
  84. #define        (kNeutralInnerRadius,            0.55)
  85. #define        (kNeutralOuterRadius,            0.55)
  86. #define        (kNeutralOptimalFactor,            0.7)
  87. #define        (kNumInnerNeutrals,            Between(0, 0))
  88. #define        (kInnerNeutralPercentLand,        0.1)
  89. #define        (kInnerNeutralPercentFlat,        0.9)
  90. #define        (kInnerNeutralTreePercentage,          0.1)
  91. #define        (kInnerNeutralLandChaos,        0.9)
  92. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  93. #define        (kInnerNeutralFlatChaos,        0.8)
  94. #define        (kInnerNeutralFlatClumps,        1)
  95.  
  96.  
  97. //////////////////////////////////////////////////////////////////////
  98. // outer neutral definitions
  99. #define        (kNumOuterNeutrals,            14)
  100. #define        (kOuterNeutralPercentLand,        0.74)
  101. #define        (kOuterNeutralPercentFlat,        0.95)
  102. #define        (kOuterNeutralTreePercentage,          0.15)
  103. #define        (kOuterNeutralLandChaos,        0.8)
  104. #define        (kOuterNeutralLandClumps,        1)
  105. #define        (kOuterNeutralFlatChaos,        0.8)
  106. #define        (kOuterNeutralFlatClumps,        1)
  107.  
  108.  
  109. //////////////////////////////////////////////////////////////////////
  110. // resource definitions
  111. #define        (kMaxResourceElevation,            3)
  112. #define        (kResourceToEdgeDistance,        2)
  113. #define        (kResourceToWaterDistance,        1)
  114.  
  115. #define        (kAnimalPerPlayer,            0)
  116. #define        (kAnimalPerNeutral,            0)
  117.  
  118. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  119.   #define  (kBerryPerPlayer,    1) 
  120.   #define  (kBerryPerNeutral,      3)
  121. #else
  122.   #define  (kBerryPerPlayer,    1)
  123.   #define  (kBerryPerNeutral,      0)
  124. #endif 
  125.  
  126. #define        (kFishPerPlayer,                0)
  127. #define        (kFishPerNeutral,                16)
  128.  
  129. #define        (kGoldPerPlayer,                1)
  130. #define        (kGoldPerNeutral,                4)
  131.  
  132. #define        (kOilPerPlayer,                0)
  133. #define        (kOilPerNeutral,                0)
  134.  
  135. #define        (kSteelPerPlayer,                1)
  136. #define        (kSteelPerNeutral,            4)
  137.  
  138. #define        (kStonePerPlayer,                1)
  139. #define        (kStonePerNeutral,            2)
  140.  
  141. #define        (kTreePerPlayer,                1)
  142. #define        (kTreePerNeutral,                0)
  143.  
  144.  
  145. //////////////////////////////////////////////////////////////////////
  146. // forest definitions
  147. #define        (kForestFreeRadius,            7)
  148. #define        (kForestsPerPlayer,            1)
  149. #define        (kForestChaosLevel,            1)
  150. #define        (kMaxClumpsPerForest,              1)
  151.  
  152.  
  153. #elif Is3Players
  154. //////////////////////////////////////////////////////////////////////
  155. // 3 PLAYERS...
  156. //////////////////////////////////////////////////////////////////////
  157.  
  158. //////////////////////////////////////////////////////////////////////
  159. // terrain definitions
  160. #define        (kMinIntElevation,            -8)
  161. #define        (kMaxIntElevation,            6)
  162. #define        (kElevationScale,                0.99)
  163. #define        (kPercentLand,                Between(.7, .7))
  164. #define        (kWaterBorder,                0)
  165. #define        (kHeightMapChaos,                Between(6, 10))
  166.                                             
  167. #define        (kMinimumStartPositionToMapEdge,    1)
  168. #define        (kOuterPushFromMapCenter,        24)
  169. #define        (kInnerPushFromMapCenter,         0)
  170.  
  171. #define        (kConvergentSampleSize,            32) 
  172. #define        (kConvergentThreshold,            20000)
  173.  
  174. //////////////////////////////////////////////////////////////////////
  175. // player definitions
  176. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  177. #define        (kPlayerInnerRadius,            0.82)
  178. #define        (kPlayerOuterRadius,            0.99)
  179. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  180. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  181. #define        (kPlayerLandChaos,            0.8)
  182. #define        (kPlayerLandClumps,            1)
  183. #define        (kPlayerFlatChaos,            0.8)
  184. #define        (kPlayerFlatClumps,            1)
  185. #define        (kPlayerTreePercentage,            0.14)
  186.  
  187. //////////////////////////////////////////////////////////////////////
  188. // inner neutral definitions
  189. #define        (kNeutralInnerRadius,            0.55)
  190. #define        (kNeutralOuterRadius,            0.55)
  191. #define        (kNeutralOptimalFactor,            0.7)
  192. #define        (kNumInnerNeutrals,            Between(0, 0))
  193. #define        (kInnerNeutralPercentLand,        0.11)
  194. #define        (kInnerNeutralPercentFlat,        0.95)
  195. #define        (kInnerNeutralTreePercentage,          0.12)
  196. #define        (kInnerNeutralLandChaos,        0.9)
  197. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  198. #define        (kInnerNeutralFlatChaos,        0.8)
  199. #define        (kInnerNeutralFlatClumps,        1)
  200.  
  201.  
  202. //////////////////////////////////////////////////////////////////////
  203. // outer neutral definitions
  204. #define        (kNumOuterNeutrals,            14)
  205. #define        (kOuterNeutralPercentLand,        0.66)
  206. #define        (kOuterNeutralPercentFlat,        0.95)
  207. #define        (kOuterNeutralTreePercentage,          0.15)
  208. #define        (kOuterNeutralLandChaos,        0.8)
  209. #define        (kOuterNeutralLandClumps,        1)
  210. #define        (kOuterNeutralFlatChaos,        0.8)
  211. #define        (kOuterNeutralFlatClumps,        1)
  212.  
  213.  
  214. //////////////////////////////////////////////////////////////////////
  215. // resource definitions
  216. #define        (kMaxResourceElevation,            3)
  217. #define        (kResourceToEdgeDistance,        2)
  218. #define        (kResourceToWaterDistance,        1)
  219.  
  220. #define        (kAnimalPerPlayer,            0)
  221. #define        (kAnimalPerNeutral,            0)
  222.  
  223. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  224.   #define  (kBerryPerPlayer,    1) 
  225.   #define  (kBerryPerNeutral,      5)
  226. #else
  227.   #define  (kBerryPerPlayer,    1)
  228.   #define  (kBerryPerNeutral,      0)
  229. #endif 
  230.  
  231. #define        (kFishPerPlayer,                0)
  232. #define        (kFishPerNeutral,                16)
  233.  
  234. #define        (kGoldPerPlayer,                1)
  235. #define        (kGoldPerNeutral,                6)
  236.  
  237. #define        (kOilPerPlayer,                0)
  238. #define        (kOilPerNeutral,                0)
  239.  
  240. #define        (kSteelPerPlayer,                1)
  241. #define        (kSteelPerNeutral,            6)
  242.  
  243. #define        (kStonePerPlayer,                1)
  244. #define        (kStonePerNeutral,            2)
  245.  
  246. #define        (kTreePerPlayer,                1)
  247. #define        (kTreePerNeutral,                0)
  248.  
  249.  
  250. //////////////////////////////////////////////////////////////////////
  251. // forest definitions
  252. #define        (kForestFreeRadius,            6.0)
  253. #define        (kForestsPerPlayer,            1)
  254. #define        (kForestChaosLevel,            1)
  255. #define        (kMaxClumpsPerForest,              1)
  256.  
  257.  
  258. #elif Is4Players
  259. //////////////////////////////////////////////////////////////////////
  260. // 4 PLAYERS...
  261. //////////////////////////////////////////////////////////////////////
  262.  
  263. //////////////////////////////////////////////////////////////////////
  264. // terrain definitions
  265. #define        (kMinIntElevation,            -8)
  266. #define        (kMaxIntElevation,            6)
  267. #define        (kElevationScale,                0.99)
  268. #define        (kPercentLand,                Between(.73, .73))
  269. #define        (kWaterBorder,                0)
  270. #define        (kHeightMapChaos,                Between(6, 10))
  271.                                             
  272. #define        (kMinimumStartPositionToMapEdge    1)
  273. #define        (kOuterPushFromMapCenter        18)
  274. #define        (kInnerPushFromMapCenter         0)
  275.  
  276. #define        (kConvergentSampleSize,            32) 
  277. #define        (kConvergentThreshold,            20)
  278.  
  279.  
  280. //////////////////////////////////////////////////////////////////////
  281. // player definitions
  282. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  283. #define        (kPlayerInnerRadius,            0.84)
  284. #define        (kPlayerOuterRadius,            0.99)
  285. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  286. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  287. #define        (kPlayerLandChaos,            0.8)
  288. #define        (kPlayerLandClumps,            1)
  289. #define        (kPlayerFlatChaos,            0.8)
  290. #define        (kPlayerFlatClumps,            1)
  291. #define        (kPlayerTreePercentage,            0.13)
  292.  
  293.  
  294. //////////////////////////////////////////////////////////////////////
  295. // inner neutral definitions
  296. #define        (kNeutralInnerRadius,            0.55)
  297. #define        (kNeutralOuterRadius,            0.55)
  298. #define        (kNeutralOptimalFactor,            0.7)
  299. #define        (kNumInnerNeutrals,            Between(0, 0))
  300. #define        (kInnerNeutralPercentLand,        0.11)
  301. #define        (kInnerNeutralPercentFlat,        0.9)
  302. #define        (kInnerNeutralTreePercentage,          0.14)
  303. #define        (kInnerNeutralLandChaos,        0.9)
  304. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  305. #define        (kInnerNeutralFlatChaos,        0.8)
  306. #define        (kInnerNeutralFlatClumps,        1)
  307.  
  308.  
  309. //////////////////////////////////////////////////////////////////////
  310. // outer neutral definitions
  311. #define        (kNumOuterNeutrals,            8)
  312. #define        (kOuterNeutralPercentLand,        0.67)
  313. #define        (kOuterNeutralPercentFlat,        0.95)
  314. #define        (kOuterNeutralTreePercentage,          0.12)
  315. #define        (kOuterNeutralLandChaos,        0.8)
  316. #define        (kOuterNeutralLandClumps,        1)
  317. #define        (kOuterNeutralFlatChaos,        0.8)
  318. #define        (kOuterNeutralFlatClumps,        1)
  319.  
  320.  
  321. //////////////////////////////////////////////////////////////////////
  322. // resource definitions
  323. #define        (kMaxResourceElevation,            3)
  324. #define        (kResourceToEdgeDistance,        1)
  325. #define        (kResourceToWaterDistance,        1)
  326.  
  327. #define        (kAnimalPerPlayer,            0)
  328. #define        (kAnimalPerNeutral,            0)
  329.  
  330. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  331.   #define  (kBerryPerPlayer,    1) 
  332.   #define  (kBerryPerNeutral,      4)
  333. #else
  334.   #define  (kBerryPerPlayer,    1)
  335.   #define  (kBerryPerNeutral,      0)
  336. #endif 
  337.  
  338. #define        (kFishPerPlayer,                0)
  339. #define        (kFishPerNeutral,                16)
  340.  
  341. #define        (kGoldPerPlayer,                1)
  342. #define        (kGoldPerNeutral,                5)
  343.  
  344. #define        (kOilPerPlayer,                0)
  345. #define        (kOilPerNeutral,                0)
  346.  
  347. #define        (kSteelPerPlayer,                1)
  348. #define        (kSteelPerNeutral,            5)
  349.  
  350. #define        (kStonePerPlayer,                1)
  351. #define        (kStonePerNeutral,            2)
  352.  
  353. #define        (kTreePerPlayer,                1)
  354. #define        (kTreePerNeutral,                0)
  355.  
  356.  
  357. //////////////////////////////////////////////////////////////////////
  358. // forest definitions
  359. #define        (kForestFreeRadius,            5.0)
  360. #define        (kForestsPerPlayer,            1)
  361. #define        (kForestChaosLevel,            1)
  362. #define        (kMaxClumpsPerForest,              1)
  363.  
  364.  
  365. #elif Is5Players
  366. //////////////////////////////////////////////////////////////////////
  367. // 5 PLAYERS...
  368. //////////////////////////////////////////////////////////////////////
  369.  
  370. //////////////////////////////////////////////////////////////////////
  371. // terrain definitions
  372. #define        (kMinIntElevation,            -8)
  373. #define        (kMaxIntElevation,            6)
  374. #define        (kElevationScale,                0.99)
  375. #define        (kPercentLand,                Between(.73, .73))
  376. #define        (kWaterBorder,                0)
  377. #define        (kHeightMapChaos,                Between(6, 10))
  378.                                             
  379. #define        (kMinimumStartPositionToMapEdge    1)
  380. #define        (kOuterPushFromMapCenter        16)
  381. #define        (kInnerPushFromMapCenter         0)
  382.  
  383. #define        (kConvergentSampleSize,            32) 
  384. #define        (kConvergentThreshold,            1)
  385.  
  386. //////////////////////////////////////////////////////////////////////
  387. // player definitions
  388. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  389. #define        (kPlayerInnerRadius,            0.86)
  390. #define        (kPlayerOuterRadius,            0.99)
  391. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  392. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  393. #define        (kPlayerLandChaos,            0.8)
  394. #define        (kPlayerLandClumps,            1)
  395. #define        (kPlayerFlatChaos,            0.8)
  396. #define        (kPlayerFlatClumps,            2)
  397. #define        (kPlayerTreePercentage,            0.13)
  398.  
  399.  
  400. //////////////////////////////////////////////////////////////////////
  401. // inner neutral definitions
  402. #define        (kNeutralInnerRadius,            0.55)
  403. #define        (kNeutralOuterRadius,            0.55)
  404. #define        (kNeutralOptimalFactor,            0.7)
  405. #define        (kNumInnerNeutrals,            Between(0, 0))
  406. #define        (kInnerNeutralPercentLand,        0.10)
  407. #define        (kInnerNeutralPercentFlat,        0.9)
  408. #define        (kInnerNeutralTreePercentage,          0.16)
  409. #define        (kInnerNeutralLandChaos,        0.9)
  410. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  411. #define        (kInnerNeutralFlatChaos,        0.8)
  412. #define        (kInnerNeutralFlatClumps,        1)
  413.  
  414.  
  415. //////////////////////////////////////////////////////////////////////
  416. // outer neutral definitions
  417. #define        (kNumOuterNeutrals,            6)
  418. #define        (kOuterNeutralPercentLand,        0.6)
  419. #define        (kOuterNeutralPercentFlat,        0.95)
  420. #define        (kOuterNeutralTreePercentage,          0.12)
  421. #define        (kOuterNeutralLandChaos,        0.8)
  422. #define        (kOuterNeutralLandClumps,        1)
  423. #define        (kOuterNeutralFlatChaos,        0.8)
  424. #define        (kOuterNeutralFlatClumps,        1)
  425.  
  426.  
  427. //////////////////////////////////////////////////////////////////////
  428. // resource definitions
  429. #define        (kMaxResourceElevation,            3)
  430. #define        (kResourceToEdgeDistance,        1)
  431. #define        (kResourceToWaterDistance,        1)
  432.  
  433. #define        (kAnimalPerPlayer,            0)
  434. #define        (kAnimalPerNeutral,            0)
  435.  
  436. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  437.   #define  (kBerryPerPlayer,    2) 
  438.   #define  (kBerryPerNeutral,      0)
  439. #else
  440.   #define  (kBerryPerPlayer,    1)
  441.   #define  (kBerryPerNeutral,      0)
  442. #endif 
  443.  
  444. #define        (kFishPerPlayer,                0)
  445. #define        (kFishPerNeutral,                16)
  446.  
  447. #define        (kGoldPerPlayer,                2)
  448. #define        (kGoldPerNeutral,                1)
  449.  
  450. #define        (kOilPerPlayer,                0)
  451. #define        (kOilPerNeutral,                0)
  452.  
  453. #define        (kSteelPerPlayer,                2)
  454. #define        (kSteelPerNeutral,            1)
  455.  
  456. #define        (kStonePerPlayer,                1)
  457. #define        (kStonePerNeutral,            1)
  458.  
  459. #define        (kTreePerPlayer,                1)
  460. #define        (kTreePerNeutral,                0)
  461.  
  462.  
  463. //////////////////////////////////////////////////////////////////////
  464. // forest definitions
  465. #define        (kForestFreeRadius,            5.0)
  466. #define        (kForestsPerPlayer,            1)
  467. #define        (kForestChaosLevel,            1)
  468. #define        (kMaxClumpsPerForest,              1)
  469.  
  470. #elif Is6Players
  471. //////////////////////////////////////////////////////////////////////
  472. // 6 PLAYERS...
  473. //////////////////////////////////////////////////////////////////////
  474.  
  475. //////////////////////////////////////////////////////////////////////
  476. // terrain definitions
  477. #define        (kMinIntElevation,            -8)
  478. #define        (kMaxIntElevation,            6)
  479. #define        (kElevationScale,                0.99)
  480. #define        (kPercentLand,                Between(.73, .73))
  481. #define        (kWaterBorder,                0)
  482. #define        (kHeightMapChaos,                Between(5, 9))
  483.             
  484. #define        (kMinimumStartPositionToMapEdge    1)
  485. #define        (kOuterPushFromMapCenter        14)
  486. #define        (kInnerPushFromMapCenter         0)    
  487.  
  488. #define        (kConvergentSampleSize,            32) 
  489. #define        (kConvergentThreshold,            1)                
  490.  
  491. //////////////////////////////////////////////////////////////////////
  492. // player definitions
  493. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  494. #define        (kPlayerInnerRadius,            0.87)
  495. #define        (kPlayerOuterRadius,            0.99)
  496. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  497. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  498. #define        (kPlayerLandChaos,            0.8)
  499. #define        (kPlayerLandClumps,            1)
  500. #define        (kPlayerFlatChaos,            0.8)
  501. #define        (kPlayerFlatClumps,            2)
  502. #define        (kPlayerTreePercentage,            0.12)
  503.  
  504.  
  505. //////////////////////////////////////////////////////////////////////
  506. // inner neutral definitions
  507. #define        (kNeutralInnerRadius,            0.55)
  508. #define        (kNeutralOuterRadius,            0.55)
  509. #define        (kNeutralOptimalFactor,            0.7)
  510. #define        (kNumInnerNeutrals,            Between(0, 0))
  511. #define        (kInnerNeutralPercentLand,        0.09)
  512. #define        (kInnerNeutralPercentFlat,        0.9)
  513. #define        (kInnerNeutralTreePercentage,          0.17)
  514. #define        (kInnerNeutralLandChaos,        0.9)
  515. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  516. #define        (kInnerNeutralFlatChaos,        0.8)
  517. #define        (kInnerNeutralFlatClumps,        1)
  518.  
  519.  
  520. //////////////////////////////////////////////////////////////////////
  521. // outer neutral definitions
  522. #define        (kNumOuterNeutrals,            6)
  523. #define        (kOuterNeutralPercentLand,        0.55)
  524. #define        (kOuterNeutralPercentFlat,        0.95)
  525. #define        (kOuterNeutralTreePercentage,          0.15)
  526. #define        (kOuterNeutralLandChaos,        0.8)
  527. #define        (kOuterNeutralLandClumps,        1)
  528. #define        (kOuterNeutralFlatChaos,        0.8)
  529. #define        (kOuterNeutralFlatClumps,        1)
  530.  
  531.  
  532. //////////////////////////////////////////////////////////////////////
  533. // resource definitions
  534. #define        (kMaxResourceElevation,            3)
  535. #define        (kResourceToEdgeDistance,        1)
  536. #define        (kResourceToWaterDistance,        1)
  537.  
  538. #define        (kAnimalPerPlayer,            0)
  539. #define        (kAnimalPerNeutral,            0)
  540.  
  541. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  542.   #define  (kBerryPerPlayer,    2) 
  543.   #define  (kBerryPerNeutral,      0)
  544. #else
  545.   #define  (kBerryPerPlayer,    1)
  546.   #define  (kBerryPerNeutral,      0)
  547. #endif 
  548.  
  549. #define        (kFishPerPlayer,                0)
  550. #define        (kFishPerNeutral,                16)
  551.  
  552. #define        (kGoldPerPlayer,                2)
  553. #define        (kGoldPerNeutral,                0)
  554.  
  555. #define        (kOilPerPlayer,                0)
  556. #define        (kOilPerNeutral,                0)
  557.  
  558. #define        (kSteelPerPlayer,                2)
  559. #define        (kSteelPerNeutral,            0)
  560.  
  561. #define        (kStonePerPlayer,                1)
  562. #define        (kStonePerNeutral,            2)
  563.  
  564. #define        (kTreePerPlayer,                1)
  565. #define        (kTreePerNeutral,                0)
  566.  
  567.  
  568. //////////////////////////////////////////////////////////////////////
  569. // forest definitions
  570. #define        (kForestFreeRadius,            5.0)
  571. #define        (kForestsPerPlayer,            1)
  572. #define        (kForestChaosLevel,            1)
  573. #define        (kMaxClumpsPerForest,              1)
  574.  
  575.  
  576. #elif Is7Players
  577. //////////////////////////////////////////////////////////////////////
  578. // 7 PLAYERS...
  579. //////////////////////////////////////////////////////////////////////
  580.  
  581. //////////////////////////////////////////////////////////////////////
  582. // terrain definitions
  583. #define        (kMinIntElevation,            -8)
  584. #define        (kMaxIntElevation,            6)
  585. #define        (kElevationScale,                0.99)
  586. #define        (kPercentLand,                Between(.7, .7))
  587. #define        (kWaterBorder,                0)
  588. #define        (kHeightMapChaos,                Between(5, 9))
  589.                                             
  590. #define        (kMinimumStartPositionToMapEdge    1)
  591. #define        (kOuterPushFromMapCenter        12)
  592. #define        (kInnerPushFromMapCenter         0)
  593.  
  594. #define        (kConvergentSampleSize,            32) 
  595. #define        (kConvergentThreshold,            1)
  596.  
  597. //////////////////////////////////////////////////////////////////////
  598. // player definitions
  599. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  600. #define        (kPlayerInnerRadius,            0.88)
  601. #define        (kPlayerOuterRadius,            0.99)
  602. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  603. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  604. #define        (kPlayerLandChaos,            0.8)
  605. #define        (kPlayerLandClumps,            1)
  606. #define        (kPlayerFlatChaos,            0.8)
  607. #define        (kPlayerFlatClumps,            1)
  608. #define        (kPlayerTreePercentage,            0.1)
  609.  
  610.  
  611. //////////////////////////////////////////////////////////////////////
  612. // inner neutral definitions
  613. #define        (kNeutralInnerRadius,            0.55)
  614. #define        (kNeutralOuterRadius,            0.55)
  615. #define        (kNeutralOptimalFactor,            0.7)
  616. #define        (kNumInnerNeutrals,            Between(0, 0))
  617. #define        (kInnerNeutralPercentLand,        0.08)
  618. #define        (kInnerNeutralPercentFlat,        0.9)
  619. #define        (kInnerNeutralTreePercentage,          0.2)
  620. #define        (kInnerNeutralLandChaos,        0.9)
  621. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  622. #define        (kInnerNeutralFlatChaos,        0.8)
  623. #define        (kInnerNeutralFlatClumps,        1)
  624.  
  625. //////////////////////////////////////////////////////////////////////
  626. // outer neutral definitions
  627. #define        (kNumOuterNeutrals,            5)
  628. #define        (kOuterNeutralPercentLand,        0.5)
  629. #define        (kOuterNeutralPercentFlat,        0.95)
  630. #define        (kOuterNeutralTreePercentage,          0.15)
  631. #define        (kOuterNeutralLandChaos,        0.8)
  632. #define        (kOuterNeutralLandClumps,        1)
  633. #define        (kOuterNeutralFlatChaos,        0.8)
  634. #define        (kOuterNeutralFlatClumps,        1)
  635.  
  636. //////////////////////////////////////////////////////////////////////
  637. // resource definitions
  638. #define        (kMaxResourceElevation,            3)
  639. #define        (kResourceToEdgeDistance,        2)
  640. #define        (kResourceToWaterDistance,        1)
  641.  
  642. #define        (kAnimalPerPlayer,            0)
  643. #define        (kAnimalPerNeutral,            0)
  644.  
  645. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  646.   #define  (kBerryPerPlayer,    2) 
  647.   #define  (kBerryPerNeutral,      0)
  648. #else
  649.   #define  (kBerryPerPlayer,    1)
  650.   #define  (kBerryPerNeutral,      0)
  651. #endif 
  652.  
  653. #define        (kFishPerPlayer,                0)
  654. #define        (kFishPerNeutral,                16)
  655.  
  656. #define        (kGoldPerPlayer,                1)
  657. #define        (kGoldPerNeutral,                3)
  658.  
  659. #define        (kOilPerPlayer,                0)
  660. #define        (kOilPerNeutral,                0)
  661.  
  662. #define        (kSteelPerPlayer,                1)
  663. #define        (kSteelPerNeutral,            3)
  664.  
  665. #define        (kStonePerPlayer,                1)
  666. #define        (kStonePerNeutral,            2)
  667.  
  668. #define        (kTreePerPlayer,                1)
  669. #define        (kTreePerNeutral,                0)
  670.  
  671.  
  672. //////////////////////////////////////////////////////////////////////
  673. // forest definitions
  674. #define        (kForestFreeRadius,            4)
  675. #define        (kForestsPerPlayer,            1)
  676. #define        (kForestChaosLevel,            1)
  677. #define        (kMaxClumpsPerForest,              1)
  678.  
  679.  
  680. #elif Is8Players
  681. //////////////////////////////////////////////////////////////////////
  682. // 8 PLAYERS...
  683. //////////////////////////////////////////////////////////////////////
  684.  
  685. //////////////////////////////////////////////////////////////////////
  686. // terrain definitions
  687. #define        (kMinIntElevation,            -8)
  688. #define        (kMaxIntElevation,            6)
  689. #define        (kElevationScale,                0.99)
  690. #define        (kPercentLand,                Between(.7, .7))
  691. #define        (kWaterBorder,                0)
  692. #define        (kHeightMapChaos,                Between(5, 9))
  693.  
  694. #define        (kMinimumStartPositionToMapEdge    1)
  695. #define        (kOuterPushFromMapCenter        20)
  696. #define        (kInnerPushFromMapCenter         0)        
  697.  
  698. #define        (kConvergentSampleSize,            32) 
  699. #define        (kConvergentThreshold,            1)                                    
  700. //////////////////////////////////////////////////////////////////////
  701. // player definitions
  702. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  703. #define        (kPlayerInnerRadius,            0.9)
  704. #define        (kPlayerOuterRadius,            0.999)
  705. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  706. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  707. #define        (kPlayerLandChaos,            0.8)
  708. #define        (kPlayerLandClumps,            1)
  709. #define        (kPlayerFlatChaos,            0.8)
  710. #define        (kPlayerFlatClumps,            2)
  711. #define        (kPlayerTreePercentage,            0.1)
  712.  
  713.  
  714. //////////////////////////////////////////////////////////////////////
  715. // inner neutral definitions
  716. #define        (kNeutralInnerRadius,            0.45)
  717. #define        (kNeutralOuterRadius,            0.45)
  718. #define        (kNeutralOptimalFactor,            0.7)
  719. #define        (kNumInnerNeutrals,            Between(0, 0))
  720. #define        (kInnerNeutralPercentLand,        0.08)
  721. #define        (kInnerNeutralPercentFlat,        0.9)
  722. #define        (kInnerNeutralTreePercentage,          0.2)
  723. #define        (kInnerNeutralLandChaos,        0.9)
  724. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  725. #define        (kInnerNeutralFlatChaos,        0.8)
  726. #define        (kInnerNeutralFlatClumps,        1)
  727.  
  728.  
  729. //////////////////////////////////////////////////////////////////////
  730. // outer neutral definitions
  731. #define        (kNumOuterNeutrals,            5)
  732. #define        (kOuterNeutralPercentLand,        0.40)
  733. #define        (kOuterNeutralPercentFlat,        0.95)
  734. #define        (kOuterNeutralTreePercentage,          0.15)
  735. #define        (kOuterNeutralLandChaos,        0.8)
  736. #define        (kOuterNeutralLandClumps,        1)
  737. #define        (kOuterNeutralFlatChaos,        0.8)
  738. #define        (kOuterNeutralFlatClumps,        1)
  739.  
  740.  
  741. //////////////////////////////////////////////////////////////////////
  742. // resource definitions
  743. #define        (kMaxResourceElevation,            3)
  744. #define        (kResourceToEdgeDistance,        2)
  745. #define        (kResourceToWaterDistance,        1)
  746.  
  747. #define        (kAnimalPerPlayer,            0)
  748. #define        (kAnimalPerNeutral,            0)
  749.  
  750. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  751.   #define  (kBerryPerPlayer,    2) 
  752.   #define  (kBerryPerNeutral,      0)
  753. #else
  754.   #define  (kBerryPerPlayer,    1)
  755.   #define  (kBerryPerNeutral,      0)
  756. #endif 
  757.  
  758. #define        (kFishPerPlayer,                0)
  759. #define        (kFishPerNeutral,                16)
  760.  
  761. #define        (kGoldPerPlayer,                1)
  762. #define        (kGoldPerNeutral,                3)
  763.  
  764. #define        (kOilPerPlayer,                0)
  765. #define        (kOilPerNeutral,                0)
  766.  
  767. #define        (kSteelPerPlayer,                1)
  768. #define        (kSteelPerNeutral,            3)
  769.  
  770. #define        (kStonePerPlayer,                1)
  771. #define        (kStonePerNeutral,            2)
  772.  
  773. #define        (kTreePerPlayer,                1)
  774. #define        (kTreePerNeutral,                0)
  775.  
  776.  
  777. //////////////////////////////////////////////////////////////////////
  778. // forest definitions
  779. #define        (kForestFreeRadius,            4.0)
  780. #define        (kForestsPerPlayer,            1)
  781. #define        (kForestChaosLevel,            1)
  782. #define        (kMaxClumpsPerForest,              1)
  783.  
  784.  
  785. #elif Is9Players
  786. //////////////////////////////////////////////////////////////////////
  787. // 9 PLAYERS...
  788. //////////////////////////////////////////////////////////////////////
  789.  
  790. //////////////////////////////////////////////////////////////////////
  791. // terrain definitions
  792. #define        (kMinIntElevation,            -10)
  793. #define        (kMaxIntElevation,            10)
  794. #define        (kElevationScale,                0.99)
  795. #define        (kPercentLand,                Between(.88, .88))
  796. #define        (kWaterBorder,                0)
  797. #define        (kHeightMapChaos,                Between(8, 15))
  798.  
  799. #define        (kMinimumStartPositionToMapEdge    1)
  800. #define        (kOuterPushFromMapCenter        10)
  801. #define        (kInnerPushFromMapCenter         0)    
  802. #define        (kConvergentSampleSize,            32) 
  803. #define        (kConvergentThreshold,            1)                                            
  804. //////////////////////////////////////////////////////////////////////
  805. // player definitions
  806. #define        (kMaxAngleBetweenTeamMembers,        70.0)
  807. #define        (kPlayerInnerRadius,            0.9)
  808. #define        (kPlayerOuterRadius,            0.999)
  809. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  810. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  811. #define        (kPlayerLandChaos,            0.8)
  812. #define        (kPlayerLandClumps,            1)
  813. #define        (kPlayerFlatChaos,            0.8)
  814. #define        (kPlayerFlatClumps,            2)
  815. #define        (kPlayerTreePercentage,            0.1)
  816.  
  817.  
  818. //////////////////////////////////////////////////////////////////////
  819. // inner neutral definitions
  820. #define        (kNeutralInnerRadius,            0.45)
  821. #define        (kNeutralOuterRadius,            0.45)
  822. #define        (kNeutralOptimalFactor,            0.7)
  823. #define        (kNumInnerNeutrals,            Between(0, 0))
  824. #define        (kInnerNeutralPercentLand,        0.08)
  825. #define        (kInnerNeutralPercentFlat,        0.9)
  826. #define        (kInnerNeutralTreePercentage,          0.2)
  827. #define        (kInnerNeutralLandChaos,        0.9)
  828. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  829. #define        (kInnerNeutralFlatChaos,        0.8)
  830. #define        (kInnerNeutralFlatClumps,        1)
  831.  
  832.  
  833. //////////////////////////////////////////////////////////////////////
  834. // outer neutral definitions
  835. #define        (kNumOuterNeutrals,            7)
  836. #define        (kOuterNeutralPercentLand,        0.3)
  837. #define        (kOuterNeutralPercentFlat,        0.95)
  838. #define        (kOuterNeutralTreePercentage,          0.25)
  839. #define        (kOuterNeutralLandChaos,        0.8)
  840. #define        (kOuterNeutralLandClumps,        2)
  841. #define        (kOuterNeutralFlatChaos,        0.8)
  842. #define        (kOuterNeutralFlatClumps,        1)
  843.  
  844.  
  845. //////////////////////////////////////////////////////////////////////
  846. // resource definitions
  847. #define        (kMaxResourceElevation,            3)
  848. #define        (kResourceToEdgeDistance,        3)
  849. #define        (kResourceToWaterDistance,        3)
  850.  
  851. #define        (kAnimalPerPlayer,            0)
  852. #define        (kAnimalPerNeutral,            0)
  853.  
  854. #define        (kBerryPerPlayer,                1)
  855. #define        (kBerryPerNeutral,            0)
  856.  
  857. #define        (kFishPerPlayer,                0)
  858. #define        (kFishPerNeutral,                24)
  859.  
  860. #define        (kGoldPerPlayer,                1)
  861. #define        (kGoldPerNeutral,                5)
  862.  
  863. #define        (kOilPerPlayer,                0)
  864. #define        (kOilPerNeutral,                0)
  865.  
  866. #define        (kSteelPerPlayer,                1)
  867. #define        (kSteelPerNeutral,            5)
  868.  
  869. #define        (kStonePerPlayer,                1)
  870. #define        (kStonePerNeutral,            2)
  871.  
  872. #define        (kTreePerPlayer,                0)
  873. #define        (kTreePerNeutral,                0)
  874.  
  875.  
  876. //////////////////////////////////////////////////////////////////////
  877. // forest definitions
  878. #define        (kForestFreeRadius,            4.0)
  879. #define        (kForestsPerPlayer,            1)
  880. #define        (kForestChaosLevel,            0.1)
  881. #define        (kMaxClumpsPerForest,              2)
  882.  
  883.  
  884. #elif Is10Players
  885. //////////////////////////////////////////////////////////////////////
  886. // 10 PLAYERS...
  887. //////////////////////////////////////////////////////////////////////
  888.  
  889. //////////////////////////////////////////////////////////////////////
  890. // terrain definitions
  891. #define        (kMinIntElevation,            -10)
  892. #define        (kMaxIntElevation,            10)
  893. #define        (kElevationScale,                0.99)
  894. #define        (kPercentLand,                Between(.88, .88))
  895. #define        (kWaterBorder,                0)
  896. #define        (kHeightMapChaos,                Between(8, 15))
  897.  
  898. #define        (kMinimumStartPositionToMapEdge    1)
  899. #define        (kOuterPushFromMapCenter        10)
  900. #define        (kInnerPushFromMapCenter         0)    
  901.  
  902. #define        (kConvergentSampleSize,            32) 
  903. #define        (kConvergentThreshold,            1)                                            
  904. //////////////////////////////////////////////////////////////////////
  905. // player definitions
  906. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  907. #define        (kPlayerInnerRadius,            0.9)
  908. #define        (kPlayerOuterRadius,            0.999)
  909. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  910. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  911. #define        (kPlayerLandChaos,            0.8)
  912. #define        (kPlayerLandClumps,            1)
  913. #define        (kPlayerFlatChaos,            0.8)
  914. #define        (kPlayerFlatClumps,            2)
  915. #define        (kPlayerTreePercentage,            0.1)
  916.  
  917.  
  918. //////////////////////////////////////////////////////////////////////
  919. // inner neutral definitions
  920. #define        (kNeutralInnerRadius,            0.45)
  921. #define        (kNeutralOuterRadius,            0.45)
  922. #define        (kNeutralOptimalFactor,            0.7)
  923. #define        (kNumInnerNeutrals,            Between(0, 0))
  924. #define        (kInnerNeutralPercentLand,        0.08)
  925. #define        (kInnerNeutralPercentFlat,        0.9)
  926. #define        (kInnerNeutralTreePercentage,          0.2)
  927. #define        (kInnerNeutralLandChaos,        0.9)
  928. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  929. #define        (kInnerNeutralFlatChaos,        0.8)
  930. #define        (kInnerNeutralFlatClumps,        1)
  931.  
  932.  
  933. //////////////////////////////////////////////////////////////////////
  934. // outer neutral definitions
  935. #define        (kNumOuterNeutrals,            7)
  936. #define        (kOuterNeutralPercentLand,        0.3)
  937. #define        (kOuterNeutralPercentFlat,        0.9)
  938. #define        (kOuterNeutralTreePercentage,          0.25)
  939. #define        (kOuterNeutralLandChaos,        0.8)
  940. #define        (kOuterNeutralLandClumps,        2)
  941. #define        (kOuterNeutralFlatChaos,        0.8)
  942. #define        (kOuterNeutralFlatClumps,        1)
  943.  
  944.  
  945. //////////////////////////////////////////////////////////////////////
  946. // resource definitions
  947. #define        (kMaxResourceElevation,            3)
  948. #define        (kResourceToEdgeDistance,        3)
  949. #define        (kResourceToWaterDistance,        3)
  950.  
  951. #define        (kAnimalPerPlayer,            0)
  952. #define        (kAnimalPerNeutral,            0)
  953.  
  954. #define        (kBerryPerPlayer,                1)
  955. #define        (kBerryPerNeutral,            0)
  956.  
  957. #define        (kFishPerPlayer,                0)
  958. #define        (kFishPerNeutral,                24)
  959.  
  960. #define        (kGoldPerPlayer,                1)
  961. #define        (kGoldPerNeutral,                5)
  962.  
  963. #define        (kOilPerPlayer,                0)
  964. #define        (kOilPerNeutral,                0)
  965.  
  966. #define        (kSteelPerPlayer,                1)
  967. #define        (kSteelPerNeutral,            5)
  968.  
  969. #define        (kStonePerPlayer,                1)
  970. #define        (kStonePerNeutral,            2)
  971.  
  972. #define        (kTreePerPlayer,                0)
  973. #define        (kTreePerNeutral,                0)
  974.  
  975.  
  976. //////////////////////////////////////////////////////////////////////
  977. // forest definitions
  978. #define        (kForestFreeRadius,            4.0)
  979. #define        (kForestsPerPlayer,            1)
  980. #define        (kForestChaosLevel,            0.1)
  981. #define        (kMaxClumpsPerForest,              2)
  982.  
  983.  
  984. #elif Is11Players
  985. //////////////////////////////////////////////////////////////////////
  986. // 11 PLAYERS...
  987. //////////////////////////////////////////////////////////////////////
  988.  
  989. //////////////////////////////////////////////////////////////////////
  990. // terrain definitions
  991. #define        (kMinIntElevation,                -10)
  992. #define        (kMaxIntElevation,                20)
  993. #define        (kElevationScale,                0.6)
  994. #define        (kPercentLand,                    Between(0.5, 0.75))
  995. #define        (kWaterBorder,                    10)
  996. #define        (kHeightMapChaos,                5.0)
  997.                                             
  998.  
  999. //////////////////////////////////////////////////////////////////////
  1000. // player definitions
  1001. #define        (kMaxAngleBetweenTeamMembers,    90.0)
  1002. #define        (kPlayerInnerRadius,            0.4)
  1003. #define        (kPlayerOuterRadius,            0.75)
  1004. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1005. #define        (kPlayerPercentFlat,            Between(0.5, 0.75))
  1006. #define        (kPlayerLandChaos,                0.8)
  1007. #define        (kPlayerLandClumps,                2)
  1008. #define        (kPlayerFlatChaos,                0.8)
  1009. #define        (kPlayerFlatClumps,                2)
  1010. #define        (kPlayerTreePercentage,            0.04)
  1011.  
  1012.  
  1013. //////////////////////////////////////////////////////////////////////
  1014. // inner neutral definitions
  1015. #define        (kNeutralInnerRadius,            0.05)
  1016. #define        (kNeutralOuterRadius,            0.4)
  1017. #define        (kNeutralOptimalFactor,            0.7)
  1018. #define        (kNumInnerNeutrals,                1)
  1019. #define        (kInnerNeutralPercentLand,        0.35)
  1020. #define        (kInnerNeutralPercentFlat,        0.5)
  1021. #define        (kInnerNeutralTreePercentage,    0.04)
  1022. #define        (kInnerNeutralLandChaos,        0.8)
  1023. #define        (kInnerNeutralLandClumps,        1)
  1024. #define        (kInnerNeutralFlatChaos,        0.8)
  1025. #define        (kInnerNeutralFlatClumps,        1)
  1026.  
  1027.  
  1028. //////////////////////////////////////////////////////////////////////
  1029. // outer neutral definitions
  1030. #define        (kNumOuterNeutrals,                1)
  1031. #define        (kOuterNeutralPercentLand,        0.35)
  1032. #define        (kOuterNeutralPercentFlat,        0.5)
  1033. #define        (kOuterNeutralTreePercentage,    0.04)
  1034. #define        (kOuterNeutralLandChaos,        0.8)
  1035. #define        (kOuterNeutralLandClumps,        1)
  1036. #define        (kOuterNeutralFlatChaos,        0.8)
  1037. #define        (kOuterNeutralFlatClumps,        1)
  1038.  
  1039.  
  1040. //////////////////////////////////////////////////////////////////////
  1041. // resource definitions
  1042. #define        (kMaxResourceElevation,            4)
  1043. #define        (kResourceToEdgeDistance,        4)
  1044. #define        (kResourceToWaterDistance,        4)
  1045.  
  1046. #define        (kAnimalPerPlayer,                5)
  1047. #define        (kAnimalPerNeutral,                2)
  1048.  
  1049. #define        (kBerryPerPlayer,                2)
  1050. #define        (kBerryPerNeutral,                2)
  1051.  
  1052. #define        (kFishPerPlayer,                5)
  1053. #define        (kFishPerNeutral,                1)
  1054.  
  1055. #define        (kGoldPerPlayer,                2)
  1056. #define        (kGoldPerNeutral,                2)
  1057.  
  1058. #define        (kOilPerPlayer,                    2)
  1059. #define        (kOilPerNeutral,                2)
  1060.  
  1061. #define        (kSteelPerPlayer,                2)
  1062. #define        (kSteelPerNeutral,                2)
  1063.  
  1064. #define        (kStonePerPlayer,                1)
  1065. #define        (kStonePerNeutral,                2)
  1066.  
  1067. #define        (kTreePerPlayer,                8)
  1068. #define        (kTreePerNeutral,                8)
  1069.  
  1070.  
  1071. //////////////////////////////////////////////////////////////////////
  1072. // forest definitions
  1073. #define        (kForestFreeRadius,                14.0)
  1074. #define        (kForestsPerPlayer,                2)
  1075. #define        (kForestChaosLevel,                0.25)
  1076. #define        (kMaxClumpsPerForest,            15)
  1077.  
  1078.  
  1079. #elif Is12Players
  1080. //////////////////////////////////////////////////////////////////////
  1081. // 12 PLAYERS...
  1082. //////////////////////////////////////////////////////////////////////
  1083.  
  1084. //////////////////////////////////////////////////////////////////////
  1085. // terrain definitions
  1086. #define        (kMinIntElevation,            -10)
  1087. #define        (kMaxIntElevation,            10)
  1088. #define        (kElevationScale,                0.99)
  1089. #define        (kPercentLand,                Between(.88, .88))
  1090. #define        (kWaterBorder,                0)
  1091. #define        (kHeightMapChaos,                Between(8, 15))
  1092.  
  1093. #define        (kMinimumStartPositionToMapEdge    1)
  1094. #define        (kOuterPushFromMapCenter        10)
  1095. #define        (kInnerPushFromMapCenter         0)                                            
  1096. //////////////////////////////////////////////////////////////////////
  1097. // player definitions
  1098. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1099. #define        (kPlayerInnerRadius,            0.9)
  1100. #define        (kPlayerOuterRadius,            0.999)
  1101. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1102. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1103. #define        (kPlayerLandChaos,            0.8)
  1104. #define        (kPlayerLandClumps,            1)
  1105. #define        (kPlayerFlatChaos,            0.8)
  1106. #define        (kPlayerFlatClumps,            2)
  1107. #define        (kPlayerTreePercentage,            0.1)
  1108.  
  1109.  
  1110. //////////////////////////////////////////////////////////////////////
  1111. // inner neutral definitions
  1112. #define        (kNeutralInnerRadius,            0.45)
  1113. #define        (kNeutralOuterRadius,            0.45)
  1114. #define        (kNeutralOptimalFactor,            0.7)
  1115. #define        (kNumInnerNeutrals,            Between(0, 0))
  1116. #define        (kInnerNeutralPercentLand,        0.08)
  1117. #define        (kInnerNeutralPercentFlat,        0.9)
  1118. #define        (kInnerNeutralTreePercentage,          0.2)
  1119. #define        (kInnerNeutralLandChaos,        0.9)
  1120. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1121. #define        (kInnerNeutralFlatChaos,        0.8)
  1122. #define        (kInnerNeutralFlatClumps,        1)
  1123.  
  1124.  
  1125. //////////////////////////////////////////////////////////////////////
  1126. // outer neutral definitions
  1127. #define        (kNumOuterNeutrals,            7)
  1128. #define        (kOuterNeutralPercentLand,        0.3)
  1129. #define        (kOuterNeutralPercentFlat,        0.9)
  1130. #define        (kOuterNeutralTreePercentage,          0.25)
  1131. #define        (kOuterNeutralLandChaos,        0.8)
  1132. #define        (kOuterNeutralLandClumps,        2)
  1133. #define        (kOuterNeutralFlatChaos,        0.8)
  1134. #define        (kOuterNeutralFlatClumps,        1)
  1135.  
  1136.  
  1137. //////////////////////////////////////////////////////////////////////
  1138. // resource definitions
  1139. #define        (kMaxResourceElevation,            3)
  1140. #define        (kResourceToEdgeDistance,        3)
  1141. #define        (kResourceToWaterDistance,        3)
  1142.  
  1143. #define        (kAnimalPerPlayer,            0)
  1144. #define        (kAnimalPerNeutral,            0)
  1145.  
  1146. #define        (kBerryPerPlayer,                1)
  1147. #define        (kBerryPerNeutral,            0)
  1148.  
  1149. #define        (kFishPerPlayer,                0)
  1150. #define        (kFishPerNeutral,                24)
  1151.  
  1152. #define        (kGoldPerPlayer,                1)
  1153. #define        (kGoldPerNeutral,                5)
  1154.  
  1155. #define        (kOilPerPlayer,                0)
  1156. #define        (kOilPerNeutral,                0)
  1157.  
  1158. #define        (kSteelPerPlayer,                1)
  1159. #define        (kSteelPerNeutral,            5)
  1160.  
  1161. #define        (kStonePerPlayer,                1)
  1162. #define        (kStonePerNeutral,            2)
  1163.  
  1164. #define        (kTreePerPlayer,                0)
  1165. #define        (kTreePerNeutral,                0)
  1166.  
  1167.  
  1168. //////////////////////////////////////////////////////////////////////
  1169. // forest definitions
  1170. #define        (kForestFreeRadius,            4.0)
  1171. #define        (kForestsPerPlayer,            1)
  1172. #define        (kForestChaosLevel,            0.1)
  1173. #define        (kMaxClumpsPerForest,              2)
  1174.  
  1175.  
  1176. #elif Is13Players
  1177. //////////////////////////////////////////////////////////////////////
  1178. // 13 PLAYERS...
  1179. //////////////////////////////////////////////////////////////////////
  1180.  
  1181. //////////////////////////////////////////////////////////////////////
  1182. // terrain definitions
  1183. #define        (kMinIntElevation,            -10)
  1184. #define        (kMaxIntElevation,            10)
  1185. #define        (kElevationScale,                0.99)
  1186. #define        (kPercentLand,                Between(.88, .88))
  1187. #define        (kWaterBorder,                0)
  1188. #define        (kHeightMapChaos,                Between(8, 15))
  1189.  
  1190. #define        (kMinimumStartPositionToMapEdge    1)
  1191. #define        (kOuterPushFromMapCenter        10)
  1192. #define        (kInnerPushFromMapCenter         0)                                            
  1193. //////////////////////////////////////////////////////////////////////
  1194. // player definitions
  1195. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1196. #define        (kPlayerInnerRadius,            0.9)
  1197. #define        (kPlayerOuterRadius,            0.999)
  1198. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1199. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1200. #define        (kPlayerLandChaos,            0.8)
  1201. #define        (kPlayerLandClumps,            1)
  1202. #define        (kPlayerFlatChaos,            0.8)
  1203. #define        (kPlayerFlatClumps,            2)
  1204. #define        (kPlayerTreePercentage,            0.1)
  1205.  
  1206.  
  1207. //////////////////////////////////////////////////////////////////////
  1208. // inner neutral definitions
  1209. #define        (kNeutralInnerRadius,            0.45)
  1210. #define        (kNeutralOuterRadius,            0.45)
  1211. #define        (kNeutralOptimalFactor,            0.7)
  1212. #define        (kNumInnerNeutrals,            Between(0, 0))
  1213. #define        (kInnerNeutralPercentLand,        0.08)
  1214. #define        (kInnerNeutralPercentFlat,        0.9)
  1215. #define        (kInnerNeutralTreePercentage,          0.2)
  1216. #define        (kInnerNeutralLandChaos,        0.9)
  1217. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1218. #define        (kInnerNeutralFlatChaos,        0.8)
  1219. #define        (kInnerNeutralFlatClumps,        1)
  1220.  
  1221.  
  1222. //////////////////////////////////////////////////////////////////////
  1223. // outer neutral definitions
  1224. #define        (kNumOuterNeutrals,            7)
  1225. #define        (kOuterNeutralPercentLand,        0.3)
  1226. #define        (kOuterNeutralPercentFlat,        0.9)
  1227. #define        (kOuterNeutralTreePercentage,          0.25)
  1228. #define        (kOuterNeutralLandChaos,        0.8)
  1229. #define        (kOuterNeutralLandClumps,        2)
  1230. #define        (kOuterNeutralFlatChaos,        0.8)
  1231. #define        (kOuterNeutralFlatClumps,        1)
  1232.  
  1233.  
  1234. //////////////////////////////////////////////////////////////////////
  1235. // resource definitions
  1236. #define        (kMaxResourceElevation,            3)
  1237. #define        (kResourceToEdgeDistance,        3)
  1238. #define        (kResourceToWaterDistance,        3)
  1239.  
  1240. #define        (kAnimalPerPlayer,            0)
  1241. #define        (kAnimalPerNeutral,            0)
  1242.  
  1243. #define        (kBerryPerPlayer,                1)
  1244. #define        (kBerryPerNeutral,            0)
  1245.  
  1246. #define        (kFishPerPlayer,                0)
  1247. #define        (kFishPerNeutral,                24)
  1248.  
  1249. #define        (kGoldPerPlayer,                1)
  1250. #define        (kGoldPerNeutral,                5)
  1251.  
  1252. #define        (kOilPerPlayer,                0)
  1253. #define        (kOilPerNeutral,                0)
  1254.  
  1255. #define        (kSteelPerPlayer,                1)
  1256. #define        (kSteelPerNeutral,            5)
  1257.  
  1258. #define        (kStonePerPlayer,                1)
  1259. #define        (kStonePerNeutral,            2)
  1260.  
  1261. #define        (kTreePerPlayer,                0)
  1262. #define        (kTreePerNeutral,                0)
  1263.  
  1264.  
  1265. //////////////////////////////////////////////////////////////////////
  1266. // forest definitions
  1267. #define        (kForestFreeRadius,            4.0)
  1268. #define        (kForestsPerPlayer,            1)
  1269. #define        (kForestChaosLevel,            0.1)
  1270. #define        (kMaxClumpsPerForest,              2)
  1271.  
  1272.  
  1273. #elif Is14Players
  1274. //////////////////////////////////////////////////////////////////////
  1275. // 14 PLAYERS...
  1276. //////////////////////////////////////////////////////////////////////
  1277.  
  1278. //////////////////////////////////////////////////////////////////////
  1279. // terrain definitions
  1280. #define        (kMinIntElevation,            -10)
  1281. #define        (kMaxIntElevation,            10)
  1282. #define        (kElevationScale,                0.99)
  1283. #define        (kPercentLand,                Between(.88, .88))
  1284. #define        (kWaterBorder,                0)
  1285. #define        (kHeightMapChaos,                Between(8, 15))
  1286.  
  1287. #define        (kMinimumStartPositionToMapEdge    1)
  1288. #define        (kOuterPushFromMapCenter        10)
  1289. #define        (kInnerPushFromMapCenter         0)                                            
  1290. //////////////////////////////////////////////////////////////////////
  1291. // player definitions
  1292. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1293. #define        (kPlayerInnerRadius,            0.9)
  1294. #define        (kPlayerOuterRadius,            0.999)
  1295. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1296. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1297. #define        (kPlayerLandChaos,            0.8)
  1298. #define        (kPlayerLandClumps,            1)
  1299. #define        (kPlayerFlatChaos,            0.8)
  1300. #define        (kPlayerFlatClumps,            2)
  1301. #define        (kPlayerTreePercentage,            0.1)
  1302.  
  1303.  
  1304. //////////////////////////////////////////////////////////////////////
  1305. // inner neutral definitions
  1306. #define        (kNeutralInnerRadius,            0.45)
  1307. #define        (kNeutralOuterRadius,            0.45)
  1308. #define        (kNeutralOptimalFactor,            0.7)
  1309. #define        (kNumInnerNeutrals,            Between(0, 0))
  1310. #define        (kInnerNeutralPercentLand,        0.08)
  1311. #define        (kInnerNeutralPercentFlat,        0.9)
  1312. #define        (kInnerNeutralTreePercentage,          0.2)
  1313. #define        (kInnerNeutralLandChaos,        0.9)
  1314. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1315. #define        (kInnerNeutralFlatChaos,        0.8)
  1316. #define        (kInnerNeutralFlatClumps,        1)
  1317.  
  1318.  
  1319. //////////////////////////////////////////////////////////////////////
  1320. // outer neutral definitions
  1321. #define        (kNumOuterNeutrals,            7)
  1322. #define        (kOuterNeutralPercentLand,        0.3)
  1323. #define        (kOuterNeutralPercentFlat,        0.9)
  1324. #define        (kOuterNeutralTreePercentage,          0.25)
  1325. #define        (kOuterNeutralLandChaos,        0.8)
  1326. #define        (kOuterNeutralLandClumps,        2)
  1327. #define        (kOuterNeutralFlatChaos,        0.8)
  1328. #define        (kOuterNeutralFlatClumps,        1)
  1329.  
  1330.  
  1331. //////////////////////////////////////////////////////////////////////
  1332. // resource definitions
  1333. #define        (kMaxResourceElevation,            3)
  1334. #define        (kResourceToEdgeDistance,        3)
  1335. #define        (kResourceToWaterDistance,        3)
  1336.  
  1337. #define        (kAnimalPerPlayer,            0)
  1338. #define        (kAnimalPerNeutral,            0)
  1339.  
  1340. #define        (kBerryPerPlayer,                1)
  1341. #define        (kBerryPerNeutral,            0)
  1342.  
  1343. #define        (kFishPerPlayer,                0)
  1344. #define        (kFishPerNeutral,                24)
  1345.  
  1346. #define        (kGoldPerPlayer,                1)
  1347. #define        (kGoldPerNeutral,                5)
  1348.  
  1349. #define        (kOilPerPlayer,                0)
  1350. #define        (kOilPerNeutral,                0)
  1351.  
  1352. #define        (kSteelPerPlayer,                1)
  1353. #define        (kSteelPerNeutral,            5)
  1354.  
  1355. #define        (kStonePerPlayer,                1)
  1356. #define        (kStonePerNeutral,            2)
  1357.  
  1358. #define        (kTreePerPlayer,                0)
  1359. #define        (kTreePerNeutral,                0)
  1360.  
  1361.  
  1362. //////////////////////////////////////////////////////////////////////
  1363. // forest definitions
  1364. #define        (kForestFreeRadius,            4.0)
  1365. #define        (kForestsPerPlayer,            1)
  1366. #define        (kForestChaosLevel,            0.1)
  1367. #define        (kMaxClumpsPerForest,              2)
  1368.  
  1369.  
  1370. #elif Is15Players
  1371. //////////////////////////////////////////////////////////////////////
  1372. // 15 PLAYERS...
  1373. //////////////////////////////////////////////////////////////////////
  1374.  
  1375. //////////////////////////////////////////////////////////////////////
  1376. // terrain definitions
  1377. #define        (kMinIntElevation,            -10)
  1378. #define        (kMaxIntElevation,            10)
  1379. #define        (kElevationScale,                0.99)
  1380. #define        (kPercentLand,                Between(.88, .88))
  1381. #define        (kWaterBorder,                0)
  1382. #define        (kHeightMapChaos,                Between(8, 15))
  1383.  
  1384. #define        (kMinimumStartPositionToMapEdge    1)
  1385. #define        (kOuterPushFromMapCenter        10)
  1386. #define        (kInnerPushFromMapCenter         0)                                            
  1387. //////////////////////////////////////////////////////////////////////
  1388. // player definitions
  1389. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1390. #define        (kPlayerInnerRadius,            0.9)
  1391. #define        (kPlayerOuterRadius,            0.999)
  1392. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1393. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1394. #define        (kPlayerLandChaos,            0.8)
  1395. #define        (kPlayerLandClumps,            1)
  1396. #define        (kPlayerFlatChaos,            0.8)
  1397. #define        (kPlayerFlatClumps,            2)
  1398. #define        (kPlayerTreePercentage,            0.1)
  1399.  
  1400.  
  1401. //////////////////////////////////////////////////////////////////////
  1402. // inner neutral definitions
  1403. #define        (kNeutralInnerRadius,            0.45)
  1404. #define        (kNeutralOuterRadius,            0.45)
  1405. #define        (kNeutralOptimalFactor,            0.7)
  1406. #define        (kNumInnerNeutrals,            Between(0, 0))
  1407. #define        (kInnerNeutralPercentLand,        0.08)
  1408. #define        (kInnerNeutralPercentFlat,        0.9)
  1409. #define        (kInnerNeutralTreePercentage,          0.2)
  1410. #define        (kInnerNeutralLandChaos,        0.9)
  1411. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1412. #define        (kInnerNeutralFlatChaos,        0.8)
  1413. #define        (kInnerNeutralFlatClumps,        1)
  1414.  
  1415.  
  1416. //////////////////////////////////////////////////////////////////////
  1417. // outer neutral definitions
  1418. #define        (kNumOuterNeutrals,            7)
  1419. #define        (kOuterNeutralPercentLand,        0.3)
  1420. #define        (kOuterNeutralPercentFlat,        0.9)
  1421. #define        (kOuterNeutralTreePercentage,          0.25)
  1422. #define        (kOuterNeutralLandChaos,        0.8)
  1423. #define        (kOuterNeutralLandClumps,        2)
  1424. #define        (kOuterNeutralFlatChaos,        0.8)
  1425. #define        (kOuterNeutralFlatClumps,        1)
  1426.  
  1427.  
  1428. //////////////////////////////////////////////////////////////////////
  1429. // resource definitions
  1430. #define        (kMaxResourceElevation,            3)
  1431. #define        (kResourceToEdgeDistance,        3)
  1432. #define        (kResourceToWaterDistance,        3)
  1433.  
  1434. #define        (kAnimalPerPlayer,            0)
  1435. #define        (kAnimalPerNeutral,            0)
  1436.  
  1437. #define        (kBerryPerPlayer,                1)
  1438. #define        (kBerryPerNeutral,            0)
  1439.  
  1440. #define        (kFishPerPlayer,                0)
  1441. #define        (kFishPerNeutral,                24)
  1442.  
  1443. #define        (kGoldPerPlayer,                1)
  1444. #define        (kGoldPerNeutral,                5)
  1445.  
  1446. #define        (kOilPerPlayer,                0)
  1447. #define        (kOilPerNeutral,                0)
  1448.  
  1449. #define        (kSteelPerPlayer,                1)
  1450. #define        (kSteelPerNeutral,            5)
  1451.  
  1452. #define        (kStonePerPlayer,                1)
  1453. #define        (kStonePerNeutral,            2)
  1454.  
  1455. #define        (kTreePerPlayer,                0)
  1456. #define        (kTreePerNeutral,                0)
  1457.  
  1458.  
  1459. //////////////////////////////////////////////////////////////////////
  1460. // forest definitions
  1461. #define        (kForestFreeRadius,            4.0)
  1462. #define        (kForestsPerPlayer,            1)
  1463. #define        (kForestChaosLevel,            0.1)
  1464. #define        (kMaxClumpsPerForest,              2)
  1465.  
  1466.  
  1467. #elif Is16Players
  1468. //////////////////////////////////////////////////////////////////////
  1469. // 16 PLAYERS...
  1470. //////////////////////////////////////////////////////////////////////
  1471.  
  1472. //////////////////////////////////////////////////////////////////////
  1473. // terrain definitions
  1474. #define        (kMinIntElevation,            -10)
  1475. #define        (kMaxIntElevation,            10)
  1476. #define        (kElevationScale,                0.99)
  1477. #define        (kPercentLand,                Between(.88, .88))
  1478. #define        (kWaterBorder,                0)
  1479. #define        (kHeightMapChaos,                Between(8, 15))
  1480.  
  1481. #define        (kMinimumStartPositionToMapEdge    1)
  1482. #define        (kOuterPushFromMapCenter        10)
  1483. #define        (kInnerPushFromMapCenter         0)                                            
  1484. //////////////////////////////////////////////////////////////////////
  1485. // player definitions
  1486. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1487. #define        (kPlayerInnerRadius,            0.9)
  1488. #define        (kPlayerOuterRadius,            0.999)
  1489. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1490. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1491. #define        (kPlayerLandChaos,            0.8)
  1492. #define        (kPlayerLandClumps,            1)
  1493. #define        (kPlayerFlatChaos,            0.8)
  1494. #define        (kPlayerFlatClumps,            2)
  1495. #define        (kPlayerTreePercentage,            0.1)
  1496.  
  1497.  
  1498. //////////////////////////////////////////////////////////////////////
  1499. // inner neutral definitions
  1500. #define        (kNeutralInnerRadius,            0.45)
  1501. #define        (kNeutralOuterRadius,            0.45)
  1502. #define        (kNeutralOptimalFactor,            0.7)
  1503. #define        (kNumInnerNeutrals,            Between(0, 0))
  1504. #define        (kInnerNeutralPercentLand,        0.08)
  1505. #define        (kInnerNeutralPercentFlat,        0.9)
  1506. #define        (kInnerNeutralTreePercentage,          0.2)
  1507. #define        (kInnerNeutralLandChaos,        0.9)
  1508. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1509. #define        (kInnerNeutralFlatChaos,        0.8)
  1510. #define        (kInnerNeutralFlatClumps,        1)
  1511.  
  1512.  
  1513. //////////////////////////////////////////////////////////////////////
  1514. // outer neutral definitions
  1515. #define        (kNumOuterNeutrals,            7)
  1516. #define        (kOuterNeutralPercentLand,        0.3)
  1517. #define        (kOuterNeutralPercentFlat,        0.9)
  1518. #define        (kOuterNeutralTreePercentage,          0.25)
  1519. #define        (kOuterNeutralLandChaos,        0.8)
  1520. #define        (kOuterNeutralLandClumps,        2)
  1521. #define        (kOuterNeutralFlatChaos,        0.8)
  1522. #define        (kOuterNeutralFlatClumps,        1)
  1523.  
  1524.  
  1525. //////////////////////////////////////////////////////////////////////
  1526. // resource definitions
  1527. #define        (kMaxResourceElevation,            3)
  1528. #define        (kResourceToEdgeDistance,        3)
  1529. #define        (kResourceToWaterDistance,        3)
  1530.  
  1531. #define        (kAnimalPerPlayer,            0)
  1532. #define        (kAnimalPerNeutral,            0)
  1533.  
  1534. #define        (kBerryPerPlayer,                1)
  1535. #define        (kBerryPerNeutral,            0)
  1536.  
  1537. #define        (kFishPerPlayer,                0)
  1538. #define        (kFishPerNeutral,                24)
  1539.  
  1540. #define        (kGoldPerPlayer,                1)
  1541. #define        (kGoldPerNeutral,                5)
  1542.  
  1543. #define        (kOilPerPlayer,                0)
  1544. #define        (kOilPerNeutral,                0)
  1545.  
  1546. #define        (kSteelPerPlayer,                1)
  1547. #define        (kSteelPerNeutral,            5)
  1548.  
  1549. #define        (kStonePerPlayer,                1)
  1550. #define        (kStonePerNeutral,            2)
  1551.  
  1552. #define        (kTreePerPlayer,                0)
  1553. #define        (kTreePerNeutral,                0)
  1554.  
  1555.  
  1556. //////////////////////////////////////////////////////////////////////
  1557. // forest definitions
  1558. #define        (kForestFreeRadius,            4.0)
  1559. #define        (kForestsPerPlayer,            1)
  1560. #define        (kForestChaosLevel,            0.1)
  1561. #define        (kMaxClumpsPerForest,              2)
  1562.  
  1563.  
  1564. //////////////////////////////////////////////////////////////////////
  1565. // End of if...elif... command
  1566. #endif
  1567.  
  1568.  
  1569. #endif        // NOTDEFINED(MEDITERRANEAN_TINY_RMV)
  1570.